package com.school.campus.service.redis;

import java.util.Collection;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.school.common.constant.ActivityCacheConstants;
import com.school.campus.domain.Activity;
import com.school.common.core.redis.RedisCache;

/**
 * 活动Redis缓存服务
 */
@Component
public class ActivityRedisService {

    @Autowired
    private RedisCache redisCache;

    /**
     * 缓存活动信息
     */
    public void cacheActivity(Activity activity) {
        String key = ActivityCacheConstants.ACTIVITY_INFO_KEY + activity.getId();
        redisCache.setCacheObject(key, activity);
        // 设置缓存过期时间为1天
        redisCache.expire(key, 86400);
    }

    /**
     * 获取缓存的活动信息
     */
    public Activity getActivity(String activityId) {
        String key = ActivityCacheConstants.ACTIVITY_INFO_KEY + activityId;
        return redisCache.getCacheObject(key);
    }

    /**
     * 删除活动缓存
     */
    public void deleteActivityCache(String activityId) {
        redisCache.deleteObject(ActivityCacheConstants.ACTIVITY_INFO_KEY + activityId);
    }

    /**
     * 设置活动开始提醒
     */
    public void setActivityStartReminder(Activity activity) {
        if (activity.getStartTime() == null) {
            return;
        }

        // 计算距离活动开始的时间（毫秒）
        long timeToStart = activity.getStartTime().getTime() - System.currentTimeMillis();
        if (timeToStart > 0) {
            String key = ActivityCacheConstants.ACTIVITY_START_REMIND_KEY + activity.getId();
            // 设置一个带过期时间的键，过期时间为活动开始时间
            redisCache.setCacheObject(key, activity.getId(),
                    Math.max(1, (int)(timeToStart / 1000)), TimeUnit.SECONDS);
        }
    }

    /**
     * 设置活动结束提醒
     */
    public void setActivityEndReminder(Activity activity) {
        if (activity.getEndTime() == null) {
            return;
        }

        // 计算距离活动结束的时间（毫秒）
        long timeToEnd = activity.getEndTime().getTime() - System.currentTimeMillis();
        if (timeToEnd > 0) {
            String key = ActivityCacheConstants.ACTIVITY_END_REMIND_KEY + activity.getId();
            // 设置一个带过期时间的键，过期时间为活动结束时间
            redisCache.setCacheObject(key, activity.getId(),
                    Math.max(1, (int)(timeToEnd / 1000)), TimeUnit.SECONDS);
        }
    }

    /**
     * 检查并处理过期的提醒键
     */
    public void checkAndProcessExpiredReminders() {
        // 检查活动开始提醒键
        processExpiredReminders(ActivityCacheConstants.ACTIVITY_START_REMIND_KEY, 2L);

        // 检查活动结束提醒键
        processExpiredReminders(ActivityCacheConstants.ACTIVITY_END_REMIND_KEY, 3L);
    }

    /**
     * 处理过期的提醒键
     */
    private void processExpiredReminders(String keyPrefix, Long targetStatus) {
        // 获取所有提醒键
        Collection<String> keys = redisCache.keys(keyPrefix + "*");
        if (keys != null && !keys.isEmpty()) {
            for (String key : keys) {
                // 检查键是否已过期（在实际Redis配置了键过期通知的情况下，这里可以简化）
                if (!redisCache.hasKey(key)) {
                    // 键已过期，处理相应的活动状态更新
                    String activityId = key.substring(keyPrefix.length());
                    // 这里可以调用活动服务更新状态
                }
            }
        }
    }
}